home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / net / sun4.md / netIESubr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-12-19  |  3.8 KB  |  203 lines
  1. /* netIESubr.c -
  2.  *
  3.  * Subroutines for the intel device driver.  These routines are to convert 
  4.  * SUN addresses to/from Intel address and offsets into Intel memory.
  5.  *
  6.  * Copyright 1985, 1988 Regents of the University of California
  7.  * Permission to use, copy, modify, and distribute this
  8.  * software and its documentation for any purpose and without
  9.  * fee is hereby granted, provided that the above copyright
  10.  * notice appear in all copies.  The University of California
  11.  * makes no representations about the suitability of this
  12.  * software for any purpose.  It is provided "as is" without
  13.  * express or implied warranty.
  14.  *
  15.  */
  16.  
  17. #ifndef lint
  18. static char rcsid[] = "$Header: /cdrom/src/kernel/Cvsroot/kernel/net/sun4.md/netIESubr.c,v 9.2 90/10/19 15:47:25 jhh Exp $ SPRITE (Berkeley)";
  19. #endif
  20.  
  21. #include <sprite.h>
  22. #include <sys.h>
  23. #include <list.h>
  24. #include <vm.h>
  25. #include <netIEInt.h>
  26.  
  27.  
  28. /*
  29.  *----------------------------------------------------------------------
  30.  *
  31.  * NetIEAddrFromSUNAddr --
  32.  *
  33.  *    Change 24-bit SUN address to Intel 24-bit address.
  34.  *
  35.  * Results:
  36.  *    The modified address.
  37.  *
  38.  * Side effects:
  39.  *    None.
  40.  *
  41.  *----------------------------------------------------------------------
  42.  */
  43.  
  44. int
  45. NetIEAddrFromSUNAddr(addr)
  46.     int    addr;
  47. {
  48.     union {
  49.     int     i;
  50.     char    ch[4];
  51.     } addrTo, addrFrom;
  52.  
  53.     addrFrom.i = addr;
  54.  
  55.     addrTo.ch[0] = addrFrom.ch[3];
  56.     addrTo.ch[1] = addrFrom.ch[2];
  57.     addrTo.ch[2] = addrFrom.ch[1];
  58.     addrTo.ch[3] = 0;
  59.  
  60.     return(addrTo.i);
  61. }
  62.  
  63.  
  64. /*
  65.  *----------------------------------------------------------------------
  66.  *
  67.  * NetIEAddrToSUNAddr --
  68.  *
  69.  *    Change 24-bit Intel address to a SUN address.
  70.  *
  71.  * Results:
  72.  *    The modified address.
  73.  *
  74.  * Side effects:
  75.  *    None.
  76.  *
  77.  *----------------------------------------------------------------------
  78.  */
  79.  
  80. int
  81. NetIEAddrToSUNAddr(addr)
  82.     int    addr;
  83. {
  84.     union {
  85.     int     i;
  86.     char    ch[4];
  87.     } addrTo, addrFrom;
  88.  
  89.     addrFrom.i = addr;
  90.  
  91.     addrTo.ch[0] = 0;
  92.     addrTo.ch[1] = addrFrom.ch[2];
  93.     addrTo.ch[2] = addrFrom.ch[1];
  94.     addrTo.ch[3] = addrFrom.ch[0];
  95.  
  96.     return(addrTo.i);
  97. }
  98.  
  99.  
  100. /*
  101.  *----------------------------------------------------------------------
  102.  *
  103.  * NetIEOffsetFromSUNAddr --
  104.  *
  105.  *    Change 24-bit SUN address to Intel 16-bit offset into
  106.  *    Intel memory.
  107.  *
  108.  * Results:
  109.  *    The Intel offset .
  110.  *
  111.  * Side effects:
  112.  *    None.
  113.  *
  114.  *----------------------------------------------------------------------
  115.  */
  116.  
  117. int
  118. NetIEOffsetFromSUNAddr(addr, statePtr)
  119.     int        addr;
  120.     NetIEState    *statePtr;
  121. {
  122.     union {
  123.     short     s;
  124.     char    ch[2];
  125.     } offsetTo, offsetFrom;
  126.  
  127.     offsetFrom.s = (short) (addr - statePtr->memBase);
  128.  
  129.     offsetTo.ch[0] = offsetFrom.ch[1];
  130.     offsetTo.ch[1] = offsetFrom.ch[0];
  131.  
  132.     return(offsetTo.s);
  133. }
  134.  
  135.  
  136. /*
  137.  *----------------------------------------------------------------------
  138.  *
  139.  * NetIEOffsetToSUNAddr --
  140.  *
  141.  *    Change 16 bit Intel offset into Intel memory to 24 bit SUN address.
  142.  *
  143.  * Results:
  144.  *    The SUN address.
  145.  *
  146.  * Side effects:
  147.  *    None.
  148.  *
  149.  *----------------------------------------------------------------------
  150.  */
  151.  
  152. int
  153. NetIEOffsetToSUNAddr(offset, statePtr)
  154.     int        offset;
  155.     NetIEState    *statePtr;
  156. {
  157.     union {
  158.     short     s;
  159.     char    ch[2];
  160.     } offsetTo, offsetFrom;
  161.  
  162.     offsetFrom.s = offset;
  163.  
  164.     offsetTo.ch[0] = offsetFrom.ch[1];
  165.     offsetTo.ch[1] = offsetFrom.ch[0];
  166.  
  167.     return(statePtr->memBase + offsetTo.s);
  168. }
  169.  
  170.  
  171. /*
  172.  *----------------------------------------------------------------------
  173.  *
  174.  * NetIEShortFromSUNShort --
  175.  *
  176.  *    Change a short on the SUN to a short on the intel.
  177.  *
  178.  * Results:
  179.  *    The Intel short .
  180.  *
  181.  * Side effects:
  182.  *    None.
  183.  *
  184.  *----------------------------------------------------------------------
  185.  */
  186.  
  187. int
  188. NetIEShortSwap(num)
  189.     int    num;
  190. {
  191.     union {
  192.     short     s;
  193.     char    ch[2];
  194.     } shortFrom, shortTo;
  195.  
  196.     shortFrom.s = (short) (num);
  197.  
  198.     shortTo.ch[0] = shortFrom.ch[1];
  199.     shortTo.ch[1] = shortFrom.ch[0];
  200.  
  201.     return(shortTo.s);
  202. }
  203.